FishMarket 1.0

home *** CD-ROM | disk | FTP | other *** search

/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 626-637 / disk_633 / galer / galer.doc < prev next >

Wrap

Text File | 1992-05-06 | 45KB | 1,281 lines

GALer V1.3 - copyright by Christian Habermann Asamstr. 17 W-8050 Freising (Germany) GALer ist ein GAL-Programmiergerät mit der dazu nötigen Software. GALer V1.3 ist SHAREWARE. Falls Sie dieses Programm zusammen mit der Hardware gebrauchen können, senden Sie mir bitte 20,- DM zu. Den Schaltplan für die Hardware und ein Flußdiagramm über die Arbeits- weise des GAL-Assemblers erhalten Sie umgehend nach Erhalt der Shareware-Gebühr. Der Vertrieb von "GALer" über PD-Serien und Mailboxen ist erlaubt. Bedingung ist allerdings, daß dabei kein Gewinn gemacht wird und daß die einzelnen Files unverändert und vollständig kopiert bzw. "upgeloaded" werden. Falls Sie den GAL-Brenner nachgebaut haben, so dürfen Sie diesen einen zum Bauteilepreis auch verkaufen. Der kommerzielle Vertrieb ist NICHT gestattet. Der Schaltplan darf nur privat und KOSTENLOS weitergegeben werden. Falls Sie "GALer" über einen PD-Händler bezogen haben und dafür mehr als 5 DM bezahlt haben, sollten Sie sich schnell einen neuen Händler suchen. ACHTUNG!!! Die Programme "GALer" und "GALerTest" senden über den Parallel- Port des Amiga Daten. Das heißt: wenn Sie dort einen Drucker, Digitizer oder sonstiges angeschlossen haben, sollten Sie diesen entweder ausschalten oder abstecken, da es sonst unter Umständen zur Beschädigung des Gerätes kommen kann. Für eventuell entstehende Schäden durch die Hard- oder Software kann ich natürlich keine Verantwortung übernehmen. Die Hardware läuft auf meinem Amiga (Amiga 1000, 2.5 MByte, 2 Diskettenlaufwerke, A2000-Tastatur, 20 MByte Festplatte, Kickstart 1.3) seit einigen Monaten fehlerfrei. Ich habe meinen Prototypen genau nach den Schaltplan aufgebaut, den auch Sie bestellen können. Das heißt, daß der Schaltplan 100%ig fehlerfrei ist. Bei gewissenhaften Nachbau kann also eigentlich gar nichts schief gehen. Der Nachbau sollte aber dennoch nur von erfahreren Elektronik-Freaks durch- geführt werden (zumindest muß man Löterfahrung haben und Schaltpläne lesen können). Näheres zur Hardware können Sie im Kapitel III erfahren. Hinweis: Diese Anleitung dient lediglich der Einführung in die Materie der GAL-Programmierung. Sie kann weiterführende Literatur (siehe unten) nicht ersetzen. Wenn Sie sich jedoch schon länger mit Digitaltechnik beschäftigen und gar nicht wissen wollen wie ein GAL intern aufgebaut ist und wie es genau funktioniert, dann müßte diese Anleitung zusammen mit den Beispiel-"Listings" ausreichen, um GALs sinnvoll einzusetzen. Versionen: V1.0: Testversion V1.1: Intuition-Umgebung hinzugefügt V1.2: einige Fehler beseitigt V1.3: Fehler im GAL-Assembler beseitigt /name.E ist jetzt nicht mehr erlaubt Die Pinnamen des zu letzt assemblierten Files können an das gezeichnete GAL angefügt werden. Inhaltsverzeichnis: Kapitel I Einführung I.1 Was sind GALs I.2 Wie ist ein solches GAL aufgebaut? I.3 Welche GALs gibt es? I.4 Was kostet so ein Ding (GAL)? I.5 Die Betriebsmodi eines GALs Kapitel II Die Software II.1 Die Eingabe-Datei II.2 Das Programm "GALer" II.3 Weitere Beispiele Kapitel III Die Hardware III.1 Programmierung von GALs III.2 Schaltungsbeschreibung III.3 Aufbau Anhang Schlüsselwörter der Eingabe-Datei Stückliste Literaturhinweise Kapitel I: Einführung ===================== I.1 Was sind GALs? ------------------ GALs (Generic Array Logic) sind programmierbare Logikbausteine. Durch entsprechende Programmierung durch den Anwender, können eine Vielzahl von Standardgatterfunktionen in einem IC, dem GAL, verwirklicht werden. Angenommen Sie benötigen für eine Digitalschaltung folgende Logikfunktionen: - UND -Gatter mit 2 Eingängen - ODER-Gatter mit 2 Eingängen - NAND-Gatter mit 2 Eingängen - NOR -Gatter mit 2 Eingängen Um diese Schaltung zu verwirklichen, sind vier (geht auch mit weniger) Standard-ICs erforderlich (74LS... bzw. 40..). Diese Funktionen lassen sich durch EINEN! GAL-Baustein ersetzen. Die Hauptaufgabe von GALs ist also die Vereinfachung von Digitalschaltungen, indem ein GAL (oder mehrere) eine Vielzahl von herkömmlichen Logik-Bau- steinen ersetzt. Ein GAL kann bei entsprechender Programmierung fast alle Logik-Funktionen ersetzen, wie z.B.: AND, OR, XOR, NAND, NOR, Inverter, FlipFlops, Decoder (vorallem Adressdecoder), Multiplexer, Zähler usw. Außerdem kann das GAL jederzeit neu programmiert werden, so daß sich Schaltungen nachträglich wesentlich einfacher ändern lassen. I.2 Wie ist ein solches GAL aufgebaut? -------------------------------------- Kernstück eines GALs ist ein Matrix. Auf die Spalten dieser Matrix werden alle Eingänge invertiert und nicht invertiert zugeführt. Im unprogrammierten Zustand des GALs sind die Spalten und Zeilen miteinander verbunden. Jede dieser Verbindungen zwischen einer Zeile und einer Spalte entspricht einer UND-Verknüpfung. Durch Programmieren des GALs werden die entsprechenden UND-Verknüpfungen gelöscht, so daß sich die gewünschte Verknüpfung ergibt. Eine Zeile heißt Produktterm, da alle Eingänge (Spalten) deren Kreuzung mit einer Zeile noch existiert, eben UND-verknüpft werden. Jeweils acht dieser Zeilen (= Produktterme) werden über ein ODER-Gatter zu der sogenannten OLMC (Output Logic Macro Cell) geführt. Es können also acht Produktterme (Zeilen) miteinander ODER-verknüpft werden. Die OLMC ist eine "konfigurierbare Ausgangszelle". Was bitte ist ein "konfigurierbare Ausgangszelle"? Ein GAL besitzt acht dieser konfigurierbaren Ausgangszellen. Diese Ausgangs- zellen können entweder als Eingang, als kombinatorischer Ausgang, als Tristate-Ausgang oder als Register-Ausgang programmiert werden. Kombinatorischer Ausgang: dieser Ausgang ist ständig aktiv (entweder HIGH oder LOW) Tristate-Ausgang : dieser Ausgang kann drei Zustände annehmen HIGH, LOW und hochohmig (hochohmig wäre mit dem Abklemmen des Pins zu vergleichen) Dies wird benötigt, wenn man mehrere Ausgänge zusammenschalten will, dabei aber nur einer dieser Ausgänge aktiv sein darf. Register-Ausgang : Bei diesem Ausgang gelangt das Verknüpfungser- gebnis der Eingänge nicht direkt an den Ausgang, sondern über ein D-FlipFlop. Erst bei einem Clock-Impuls gelangt das Ergebnis zu dem entsprechenden Ausgang. Wenn /OE auf HIGH liegt, geht der Ausgang in den hochohmigen Zustand. Neben der Matrix gibt es in einem GAL noch mehrere "Bits": ( (n) bedeutet dabei, daß diese Bits für jeden Ausgang extra vorhanden sind) XOR (n) : Mit diesem Bit kann das Ergebnis der Verknüpfung invertiert werden. XOR (n) = 0 : Ausgang active LOW XOR (n) = 1 : Ausgang active HIGH SYN, AC0, AC1(n): Mit diesen Bits wird bestimmt, in welchem Betriebsmodus sich das GAL befinden soll. Im wesentlichen gibt es drei Betriebsmodi: Betriebsmodus 1: SYN = 1 AC0 = 0 AC1(n) = 1 : OLMC als Eingang AC1(n) = 0 : OLMC als kombinatorischer Ausgang Betriebsmodus 2: SYN = 1 AC0 = 1 AC1(n) = 1 : Tristate-Ausgang Betriebsmodus 3: SYN = 0 AC0 = 1 AC1(n) = 1 : OLMC als Tristate-Ausgang AC1(n) = 0 : OLMC als Register-Ausgang PT0...63: (PT = Produkttermfreigabe) Diese Bits bestimmen, ob die Zeilen 0...63 in der Matrix des GALs gültig sein sollen oder nicht. PTx = 1: UND-Verknüpfung in der Zeile x sind gültig PTx = 0: UND-Verknüpfungen in der Zeile x sollen nicht berücksichtigt werden (haben also keine Auswirkung auf den Ausgang) (x = zwischen 0 und 63; in der Matrix gibt es 64 Zeilen, so daß jede Zeile individuell aktiviert bzw. deaktiviert werden kann) Diese 82 Bits sind zum sogenannten Architektur-Kontroll-Wort (ACW) zu- sammengefaßt. Der Aufbau dieses ACW wird im Kapitel III näher beschrieben. Signatur: Hier stehen acht Bytes für eigene Anwendungen zur Verfügung. In der Regel wird hier ein kleiner Kommentar oder die Versions- nummer des GALs als ASCII-Text abgelegt. Sicherheitszelle: (Security-Bit) Durch setzen dieses Bits wird das GAL gegen unerlaubtes Kopieren geschützt. Das Auslesen der Matrix ist nicht mehr möglich. Da aber die restlichen Bits noch gelesen werden können, ist dieser Schutz nicht sehr effektiv. Bulk Erase: Durch programmieren dieser Zelle wird das gesammte GAL gelöscht. Ein GAL kann so ca. einhundertmal! neu programmiert werden. I.3 Welche GALs gibt es? ------------------------ Am gebräuchlichsten sind die Typen GAL16V8 und GAL20V8. Diese werden auch durch dieses GAL-Programmiergerät unterstützt. Pinbelegungen: GAL16V8: ---- ---- Eingang oder Clock 1| |20 +5V Eingang 2| |19 konfigurierbare Ausgangszelle Eingang 3| |18 konfigurierbare Ausgangszelle Eingang 4| |17 konfigurierbare Ausgangszelle Eingang 5| |16 konfigurierbare Ausgangszelle Eingang 6| |15 konfigurierbare Ausgangszelle Eingang 7| |14 konfigurierbare Ausgangszelle Eingang 8| |13 konfigurierbare Ausgangszelle Eingang 9| |12 konfigurierbare Ausgangszelle GND 10| |11 Eingang oder /OE --------- GAL20V8: ---- ---- Eingang oder Clock 1| |24 +5V Eingang 2| |23 Eingang Eingang 3| |22 konfigurierbare Ausgangszelle Eingang 4| |21 konfigurierbare Ausgangszelle Eingang 5| |20 konfigurierbare Ausgangszelle Eingang 6| |19 konfigurierbare Ausgangszelle Eingang 7| |18 konfigurierbare Ausgangszelle Eingang 8| |17 konfigurierbare Ausgangszelle Eingang 9| |16 konfigurierbare Ausgangszelle Eingang 10| |15 konfigurierbare Ausgangszelle Eingang 11| |14 Eingang GND 12| |13 Eingang oder /OE --------- Aus der Pinbelegung erkennt man, daß sich die beiden GAL-Typen GAL16V8 und GAL20V8 nach Außen hin nur durch die Anzahl der Eingänge unterscheiden. So hängt die Wahl, ob man ein GAL16V8 oder GAL20V8 verwenden soll, nur von der Anzahl der benötigten Eingänge ab. I.4 Was kostet so ein Ding (GAL)? --------------------------------- Das GAL16V8 kostet um die 5,- DM und das GAL20V8 um die 8,- DM (mit fallender Tendenz). I.5 Die Betriebsmodi eines GALs ------------------------------- Wie unter I.2 bereits erwähnt wurde, bestimmen die Bits SYN, AC0 und AC1(n) in welchen Modus sich das GAL befindet. Von diesem Modus hängt die Pin-Belegung des GALs ab. GAL16V8: Betriebs-|Betriebs-|Betriebs-| |Betriebs-|Betriebs-|Betriebs-| modus 1 |modus 2 |modus 3 | |modus 1 |modus 2 |modus 3 | ------------------------------ ------------------------------- | | --- --- | | E | E | Clock 1| |20 +5V | +5V | +5V E | E | E 2| |19 E/K | T* | E/T/R E | E | E 3| |18 E/K | E/T | E/T/R E | E | E 4| |17 E/K | E/T | E/T/R E | E | E 5| |16 K | E/T | E/T/R E | E | E 6| |15 K | E/T | E/T/R E | E | E 7| |14 E/K | E/T | E/T/R E | E | E 8| |13 E/K | E/T | E/T/R E | E | E 9| |12 E/K | T* | E/T/R GND | GND | GND 10| |11 E | E | /OE ------- GAL20V8: Betriebs-|Betriebs-|Betriebs-| |Betriebs-|Betriebs-|Betriebs-| modus 1 |modus 2 |modus 3 | |modus 1 |modus 2 |modus 3 | ------------------------------ ------------------------------- | | --- --- | | E | E | Clock 1| |24 +5V | +5V | +5V E | E | E 2| |23 E | E | E E | E | E 3| |22 E/K | T* | E/T/R E | E | E 4| |21 E/K | E/T | E/T/R E | E | E 5| |20 E/K | E/T | E/T/R E | E | E 6| |19 K | E/T | E/T/R E | E | E 7| |18 K | E/T | E/T/R E | E | E 8| |17 E/K | E/T | E/T/R E | E | E 9| |16 E/K | E/T | E/T/R E | E | E 10| |15 E/K | T* | E/T/R E | E | E 11| |14 E | E | E GND | GND | GND 12| |13 E | E | /OE ------- Abkürzungen: E : Eingang K : kombinatorischer Ausgang T : Tristate-Ausgang T* : Tristate-Ausgang ohne Rückkopplung auf die Matrix, was nur heißt, daß dieser Ausgang nicht als Eingang ver- wendet werden kann R : Register-Ausgang Clock: Takt für D-FlipFlops; nur für die Pins interessant, die als Register-Ausgang programmiert sind /OE : Output Enable (low aktiv): aktiviert die Register- ausgänge (Erklärung der Begriffe siehe I.2) Aus der Pinbelegung ist z.B. ersichtlich, daß die Pins 15 und 16 des GAL16V8 bzw. die Pins 18 und 19 des GAL20V8 nicht als Eingänge programmiert werden können, wenn sich das GAL im Betriebsmodus 1 be- findet. Das Gleiche gilt für die Pins 12 und 19 bzw. 15 und 22 für den Betriebsmodus 2. Im Betriebsmodus 1 sind die Pins 1 und 11 (GAL16V8) bzw. die Pins 1 und 13 (GAL20V8) für Clock und /OE reserviert. Diese Pins können also nicht wie in den anderen beiden Modi, als Eingänge verwendet werden. Angenommen Sie benötigen für Ihr GAL zumindest einen Registerausgang. Dann ist bereits der Betriebsmodus 3 festgelegt. Wenn Sie aber mindestens einen Tristate-Ausgang benötigen und keinen Registerausgang, dann befindet sich das GAL im Betriebsmodus 2. Wenn Sie weder einen Tristate- noch einen Register-Ausgang benötigen, ist Betriebsmodus 1 zu verwenden. Kapitel II: Die Software ======================== Im Prinzip können Sie fast das ganze Kapitel I wieder vergessen. Im Prinzip - wohlgemerkt. Was Sie sich unbedingt merken sollten, ist die Pinbelegung der GALs in den verschiedenen Modi. Dadurch lassen sich unnötige Fehler vermeiden. Die Bestimmung des Betriebsmodus und die anderen Parameter, die bei der GAL-Programmierung zu berücksichtigen sind, nimmt Ihnen die Software "GALer" ab. II.1 Die Eingabe-Datei ---------------------- Als erstes muß mit Hilfe eines Texteditors eine sogenannte Eingabe-Datei (Source-File) erstellt werden. Diese Datei muß folgende Informationen enthalten: 1. den GAL-Typ (GAL16V8 oder GAL20V8) 2. einen 8 Byte langen Text, der als Kommentar in das GAL geschrieben werden soll (Signatur, siehe I.2) 3. die Pinnamen - hier werden den Pinnummern Namen zugewiesen, was wesentlich anschaulicher ist 4. die Boole'schen Gleichungen 5. Das Schlüsselwort DESCRIPTION - nach diesem Wort kann ein beliebiger Text stehen. Dieser Text beschreibt in der Regel die Funktion des GALs. Dadurch weiß man auch nach Jahren noch, für was das GAL eigentlich programmiert wurde. Bevor ich jetzt noch länger 'rum schwafle, hier ein BEISPIEL (freu, jubel). Beispiel 1: Angenommen Sie benötigen für eine Schaltung folgende Gatter: - ein AND mit 3 Eingängen - ein NAND mit 2 Eingängen - ein OR mit 2 Eingängen - eine kleine Digitalschaltung in der die Ausgänge von 2 AND-Gattern zu den Eingängen eines OR-Gatters führen Schaltbilder: AND: +----+ W = A * B * C A ----| | B ----| & |---- W C ----| | +----+ NAND: +----+ /X = D * E D ----| | | & |o--- X E ----| | +----+ OR: +----+ Y = F + G F ----| | | >1 |---- Y G ----| | +----+ kleine Digital- +----+ Z = H * I + J * K schaltung: H ----| | | & |----+ I ----| | | +----+ +----+ +---| | | <1 |---- Z +----+ +---| | J ----| | | +----+ | & |----+ K ----| | +----+ Legende: * : UND - Verknüpfung + : ODER - Verknüpfung / : low aktiv Um das Eingabe-File zu erstellen, ist zuerst der GAL-Typ zu bestimmen. Für die Verwirklichung der obigen Logik-Funktionen werden insgesamt 11 Eingänge und 4 Ausgänge benötigt. Aus Kapitel I wissen wir (oder auch nicht), daß die Wahl des GALs, von der Anzahl der Eingänge abhängt. Die Anzahl der Eingänge wiederrum, hängt von dem Betriebsmodus ab (siehe unter I.5, Pinbelegung in den einzelnen Modi). Da weder Tristate- noch Register-Ausgänge verwendet werden, wird sich das GAL nach der Programmierung im Betriebsmodus 1 befinden. Daraus folgt, das GAL16V8 10 Eingänge und 8 konfigurierbare Ausgänge be- sitzt. Da wir nur 4 Ausgänge benötigen, könnten wir die Restlichen als Eingänge programmieren, so daß wir insgesammt die benötigten 11 Eingänge und 4 Ausgänge zur Verfügung haben. Daraus folgt, daß GAL16V8 für unsere Aufgabe ausreichend ist. GAL20V8 ginge zwar auch, es wären aber wesentlich mehr Eingänge unbenützt (Verschwendung). Als zweites benötigen wir einen Text für die Signatur, der max. acht Zeichen lang sein darf - z.B. "Beispiel". Als nächstes kommen die Pin-Definitionen. Hier werden einfach die Pins 1 bis 20 der Reihe nach mit ihrem Namen, aufgelistet. Nichtverwendete Pins müssen mit "NC" (not connected) gekennzeichnet werden, Masse mit GND und +5V mit VCC. Hier: B C D E F G H I J GND K NC NC NC Z Y X W A VCC Das heißt: Pin 1 := B Eingang Pin 2 := C Eingang Pin 3 := D Eingang Pin 4 := E Eingang Pin 5 := F Eingang Pin 6 := G Eingang Pin 7 := H Eingang Pin 8 := I Eingang Pin 9 := J Eingang Pin 10 := GND Pin 11 := K Eingang Pin 12 := NC nicht verwendet Pin 13 := NC nicht verwendet Pin 14 := NC nicht verwendet Pin 15 := Z kombinatorischer Ausgang Pin 16 := Y kombinatorischer Ausgang Pin 17 := X kombinatorischer Ausgang Pin 18 := W kombinatorischer Ausgang Pin 19 := A (konfigurierbarer Ausgang als Eingang def.) Pin 20 := VCC GAL16V8 ---- ---- B 1| |20 VCC C 2| |19 A D 3| |18 W E 4| |17 X F 5| |16 Y G 6| |15 Z H 7| |14 NC I 8| |13 NC J 9| |12 NC GND 10| |11 K --------- Der nächste Punkt sind die Boole'schen Gleichungen. W = A * B * C /X = D * E Y = F + G Z = H * I + J * K Somit haben wir alle Dinge, die man für das Eingabe-File benötigt. Nun stellt sich aber die Frage wie dieses File aufgebaut ist: In der 1. Zeile muß der GAL-Typ stehen. Hier "GAL16V8" In der 2. Zeile muß die Signatur stehen. Hier "Beispiel" Danach folgen die Pin-Definitionen: B C D E F G H I J GND K NC NC NC Z Y X W A VCC dann die Boole'schen Gleichungen: W = A * B * C /X = D * E Y = F + G Z = H * I + J * K und das Schlüsselwort DESCRIPTION. Jetzt können Sie mit Hilfe eines Texteditors das Eingabe-File erstellen und mit beispiel.pld abspeichern. Dabei dürfen Sie den Anhang ".pld" nicht weglassen. So sollte das Eingabe-File schließlich aussehen: (**** kennzeichnet File-Anfang und File-Ende) ****************************************************** GAL16V8 hier darf ein Kommentar stehen Beispiel hier darf ein Kommentar stehen B C D E F G H I J GND K NC NC NC Z Y X W A VCC W = A * B * C /X = D * E Y = F + G Z = H * I + J * K DESCRIPTION: ab hier darf ein Kommentar stehen ****************************************************** Wie erhält man aber jetzt aus dem Eingabe-File, das programmierte GAL? Dazu wird das Programm "GALer" benötigt. II.2 Das Programm "GALer" ------------------------- "GALer" hat die Aufgabe mit Hilfe der Eingabe-Datei, ein programmiertes GAL zu erstellen. Zunächst die einzelnen Menüpunkte des Programms: Projekt: Quit GALer verlassen GAL-Typ: GAL16V8 hier kann der zu programmierende GAL-Typ GAL20V8 eingestellt werden GAL : löschen GAL löschen programmieren GAL programmieren kopieren GAL kopieren Leertest testen, ob GAL leer ist setze Security-Bit das Security-Bit (siehe I.2) setzen GAL-Assembler: Jedec-Datei soll Jedec-File erstellt werden? Fuse-Matrix soll Fuse-File erstellt werden? Chip-Diagramm soll Chip-Diagramm erstellt werden? Pin-Belegung soll Pin-Belegungs-File erstellt werden? Datei assemblieren Eingabe-Datei assemblieren GAL-Disassembler: Signatur lesen Signatur eines GALs ausgeben ACW lesen Architektur-Kontroll-Wort ausgeben Jedec-Datei erstellen Jedec-Datei eines bereits programmierten GALs erstellen GAL-Prüfer: Pinnamen zeigen Falls bereits eine Eingabe-Datei assembliert wurde und der eingestellte GAL-Typ mit dem Typ in der Eingabe-Datei übereinstimmt, so fügt diese Funktion die entsprechenden Pinnamen an das gezeichnete GAL an. Pinnamen löschen löscht die Pinnamen am GAL wieder Prüfmuster programmiertes GAL auf Funktion über- prüfen - nähere Beschreibung siehe unten Um ein GAL zu programmieren, muß zunächst das Eingabe-File in das so- genannte Jedec-File umgewandelt werden. Diese Aufgabe übernimmt der GAL-Assembler. Das Jedec-File (Endung ".jed") ist ein "Text"-File in dem sämtliche Bits die in einem GAL gesetzt werden können, der Reihe nach auf- gelistet sind. Den Zustand der Bits (0 oder 1) ermittelt der GAL-Assembler aus der Eingabe-Datei. Neben dem Jedec-File kann der GAL-Assembler noch drei weiter Files generieren. Diese Files dienen aber lediglich der Dokumen- tation. Das Fuse-File (Endung ".fus") zeigt den Zustand der Bits in der Logik-Matrix. Das Chip-Diagramm (Endung ".chp") zeigt den Anschlußplan des GALs und das Pin-Belegungs-File (Endung ".pin") listet alle Pins auf und zeigt, ob diese als Eingang oder Ausgang programmiert sind. Die Files können von einem beliebigen Texteditor gelesen und eventuell nachbearbeitet werden. Bei der Eingabe von Filenamen in "GALer" ist zu beachten, daß die Endungen (".jed", ".chp", ".pin", ".pld") der einzelnen File-Typen (Jedec-, Chip-, Pin-, Eingabe-File) NICHT mit angegeben werden dürfen. Nachdem der GAL-Assembler aus der Eingabe-Datei (Source-File) das Jedec- File erstellt hat kann das GAL mit Hilfe dieses Jedec-Files, programmiert werden. Dazu wählt man einfach "programmieren" an und gibt den File-Namen des Jedec-Files ein (ohne die Endung ".jed"!!!). Sobald das GAL dann programmiert ist erscheint ein Requester, der einen darauf aufmerksam macht, daß das GAL jetzt programmiert ist und aus der Fassung genommen werden kann. Vorgehensweise bei der Programmierung von GALs: 1. mit Texteditor das Eingabe-File erstellen ("name.pld") 2. Eingabe-File assemblieren -> Jedec-File ("name.jed") 3. GAL-Typ einstellen (GAL16V8 oder GAL20V8) 4. GAL in die Fassung einsetzen 5. "Leertest" anwählen Wenn das GAL nicht leer ist, muß es durch Anwählen von "löschen" zuerst gelöscht werden, bevor es programmiert werden kann. 6. "programmieren" anwählen 7. GAL aus der Fassung entfernen - fertig Nachdem das GAL programmiert wurde stellt sich immer die Frage, ob sich das GAL auch so verhält, wie man es sich eigentlich vorgestellt hat. Dazu gibt es einen GAL-Prüfer. Um ein GAL auf seine Funktion hin zu über- prüfen, muß es natürlich zuerst wieder in die Fassung gesteckt werden und gegebenenfalls der GAL-Typ wieder richtig eingestellt werden. Jetzt kann der Menüpunkt "GAL-Prüfer - Prüfmuster" angewählt werden. In der Mitte des Screens sehen Sie symbolisch ein GAL abgebildet. Im GAL selbst, sind einige 'E's und 'A's zu sehen. Das 'E' steht für Eingang und das 'A' für Ausgang. Das 'A' ist ein Gadget. Durch Anklicken wird das 'A' zu einem 'E' und durch nochmaliges Anklicken wieder zu einem 'A'. Das heißt, Sie können bestimmen, ob dieser Pin als Eingang oder als Ausgang behandelt werden soll. Falls ein Pin ein Eingang ist, kann durch ein weiteres Gadget bestimmt werden ob der Eingang auf "High" ('H') oder auf "Low" ('L') ge- legt werden soll. Die Ausgänge sind blau umrandet. Ein Ausgang kann drei Zustände annehmen: 'H' (High), 'L' (Low) und 'Z' (hochohmig). Wenn Sie das GAL aus dem obigen Beispiel verwenden, muß zunächst Pin 19 (="A") durch Anklicken von 'A' (das bei Pin 19), als Eingang definiert werden, da dieser Pin im obigen Beispiel eben als Eingang programmiert wurde. Die Eingänge des AND-Gatters sind: Pin 19 (="A"), Pin 1 (="B"), Pin 2 (="C") Der Ausgang ist Pin 18 (="W"). Wenn Sie jetzt die Eingänge des AND-Gatters durch Anklicken der Pegel-Gadgets auf HIGH legen, so muß der Ausgang (=Pin 18) ebenfalls auf HIGH gehen. Tut er das nicht oder geht der Ausgang auch bei anderen Kombinationen als bei "A"=HIGH, "B"=HIGH, "C"=HIGH auf HIGH, so liegt wahrscheinlich ein Fehler in der Eingabe-Datei vor. Diese sollte dann nocheinmal überprüft und gegebenenfalls korrigiert werden. Wurde ein Fehler gefunden, so muß das GAL zuerst gelöscht werden bevor es neu programmiert werden kann (ein GAL kann bis zu einhundertmal gelöscht und neu programmiert werden). Auf diese Art und Weise läßt sich das gesamte GAL überprüfen. Wenn das GAL vollständig getestet wurde und kein Fehler gefunden wurde, so kann es in die Schaltung eingebaut werden. II.3 Weitere Beispiele ---------------------- Als nächstes möchte ich ein Beispiel zu Tristate-Ausgängen bringen. /A ---------+ |\| | \ B -------| +------------------------ Y1 | / |/ VCC | +----+ |\| C -------| | | \ | >1 |-----------| +------- Y2 D -------| | | / +----+ |/ +----+ E -------| | | & |------+ F -------| | | +----+ | |\| | \ G -----------------| +o------------- Y3 | / |/ Y1 soll nur dann den Zustand von "B" annehmen, wenn "A" = LOW ist. Y2 soll ständig aktiv sein (entweder H oder L - abhängig von "B" und "C"). Dies entspricht einem "kombinatorischen" Ausgang. Y3 soll nur dann aktiv sein, wenn "D" UND "E" = HIGH sind. GAL16V8 ---- ---- A 1| |20 VCC B 2| |19 Y1 C 3| |18 Y2 D 4| |17 Y3 E 5| |16 NC F 6| |15 NC G 7| |14 NC NC 8| |13 NC NC 9| |12 NC GND 10| |11 NC --------- Im Eingabe-File werden die Tristate-Ausgänge durch ein ".T" gekennzeichnet. Die Tristate-Freigabe erfolgt anschließend mit einem ".E". Fehlt die Tristate-Freigabe, so wird ständige Freischaltung angenommen (=VCC). Tristate-Freigabe = GND entspricht ständigem Sperren (=hochohmig). Achtung: Bei Tristate-Ausgängen können maximal sieben Produktterme verwendet werden (bei allen anderen Ausgangsarten sind es maximal acht). In der Tristate-Freigabe darf nur EIN Produktterm verwendet werden (kein OR). Das Eingabe File sieht wie folgt aus: ****************************************************** GAL16V8 Bsp.2 A B C D E F G NC NC GND NC NC NC NC NC NC Y3 Y2 Y1 VCC Y1.T = B Y2.T = C + D Y3.T = /G Y1.E = /A Y3.E = E * F DESCRIPTION ****************************************************** Als letztes Beispiel wird die Verwendung von Register-Ausgängen gezeigt. Das Beispiel stammt aus dem Buch "Programmable Logic Manual - SGS Thomson". Zunächst die Pin-Belegung: GAL20V8 ---- ---- (Input) Clock 1| |24 VCC (Input) D0 2| |23 CARRYIN (Input) (Input) D1 3| |22 Q0 (Output) (Input) D2 4| |21 Q1 (Output) (Input) D3 5| |20 Q2 (Output) (Input) D4 6| |19 Q3 (Output) (Input) D5 7| |18 Q4 (Output) (Input) D6 8| |17 Q5 (Output) (Input) LD 9| |16 Q6 (Output) (Input) CLR 10| |15 CARRYOUT (Output) 11| |14 GND 12| |13 /OE --------- Da Register verwendet werden heißt das, daß sich das GAL im Betriebs- modus 3 befindet. Dies bedeutet, daß die Pins 1 und 13 für Clock und /OE reserviert sind. Wenn /OE auf HIGH liegt, so gehen alle Register- ausgänge (Q0-Q6) auf "hochohmig" (=Z). Wenn CARRYIN = HIGH ist und am Clock-Eingang ein LOW-HIGH-Impuls ankommt, so wird der Binärwert an den Ausgängen um eins erhöht. Wenn CLR = HIGH ist und ein Clock-Impuls (LOW-HIGH) anliegt, so werden die Ausgänge wieder auf 0 zurückgesetzt. Durch die Eingänge D0-D6 kann der Zähler vorgeladen werden. Durch LD = HIGH und einem Clock-Impuls werden die Werte von D0-D6 in Q0-Q6 übernommen. Mit CARRYOUT und CARRYIN können mehrere dieser Zähler hinter- einander geschalten werden. Im Eingabe-File werden Register-Ausgänge mit ".R" gekennzeichnet. Es sind maximal acht Produktterme pro Register-Ausgang erlaubt. ****************************************************** GAL20V8 7BITCNTR 7-Bit-Counter Clock D0 D1 D2 D3 D4 D5 D6 LD CLR NC GND /OE NC CARRYOUT Q6 Q5 Q4 Q3 Q2 Q1 Q0 CARRYIN VCC Q0.R = /CLR * D0 * LD + CARRYIN * /CLR * /LD * /Q0 Q1.R = /CLR * D1 * LD + /CLR * /LD * /Q0 * Q1 + CARRYIN * /CLR * /LD * Q0 * /Q1 Q2.R = /CLR * D2 * LD + /CLR * /LD * /Q0 * Q2 + /CLR * /LD * /Q1 * Q2 + CARRYIN * /CLR * /LD * Q0 * Q1 * /Q2 Q3.R = /CLR * D3 * LD + /CLR * /LD * /Q0 * Q3 + /CLR * /LD * /Q1 * Q3 + /CLR * /LD * /Q2 * Q3 + CARRYIN * /CLR * /LD * Q0 * Q1 * Q2 * /Q3 Q4.R = /CLR * D4 * LD + /CLR * /LD * /Q0 * Q4 + /CLR * /LD * /Q1 * Q4 + /CLR * /LD * /Q2 * Q4 + /CLR * /LD * /Q3 * Q4 + CARRYIN * /CLR * /LD * Q0 * Q1 * Q2 * Q3 * /Q4 Q5.R = /CLR * D5 * LD + /CLR * /LD * /Q0 * Q5 + /CLR * /LD * /Q1 * Q5 + /CLR * /LD * /Q2 * Q5 + /CLR * /LD * /Q3 * Q5 + /CLR * /LD * /Q4 * Q5 + CARRYIN * /CLR * /LD * Q0 * Q1 * Q2 * Q3 * Q4 * /Q5 Q6.R = /CLR * D6 * LD + /CLR * /LD * /Q0 * Q6 + /CLR * /LD * /Q1 * Q6 + /CLR * /LD * /Q2 * Q6 + /CLR * /LD * /Q3 * Q6 + /CLR * /LD * /Q4 * Q6 + /CLR * /LD * /Q5 * Q6 + CARRYIN * /CLR * /LD * Q0 * Q1 * Q2 * Q3 * Q4 * Q5 * /Q6 CARRYOUT.T = CARRYIN * /LD * Q0 * Q1 * Q2 * Q3 * Q4 * Q5 * Q6 DESCRIPTION ****************************************************** Kapitel III: Die Hardware ========================= III.1 Programmierung von GALs ----------------------------- Als erstes stellt sich natürlich die Frage wie ein GAL programmiert werden kann, wenn doch bereits alle Pins belegt sind und keine Pins für die Programmierung mehr frei sind. Legt man am Pin 2 eines GALs jedoch 16.5 V an, so ändert sich die Pinbelegung. 16.5 V an Pin 2 => GAL16V8 ---- ---- VIL 1| |20 +5V EDIT 2| |19 P,/V RAG1 3| |18 RAG0 RAG2 4| |17 VIL RAG3 5| |16 VIL RAG4 6| |15 VIL RAG5 7| |14 VIL SCLK 8| |13 VIL SDIN 9| |12 SDOUT GND 10| |11 /STR --------- GAL20V8 ---- ---- VIL 1| |24 +5V EDIT 2| |23 VIL RAG1 3| |22 P,/V RAG2 4| |21 RAG0 RAG3 5| |20 VIL VIL 6| |19 VIL VIL 7| |18 VIL RAG4 8| |17 VIL RAG5 9| |16 VIL SCLK 10| |15 SDOUT SDIN 11| |14 VIL GND 12| |13 /STR --------- Ob das GAL programmiert oder ausgelesen werden soll, hängt vom Pegel von P,/V ab. Ein HIGH bedeutet programmieren, ein LOW lesen. An den Pins RAG0-RAG5 wird die zu lesende/programmierende Adresse angelegt. Das Programmieren geschieht wie folgt: Nach Anlegen der Adresse an RAG0-RAG5, müssen die zu schreibenden Bits an SDIN (seriell) angelegt und durch einen LOW-HIGH-Impuls an SCLK in ein internes Schieberegister getaktet werden. Ein LOW-Impuls am /STR-Pin programmiert schließlich die adressierte Zelle. Der Impuls muß eine Dauer von 10ms haben. Dies wiederholt man solange, bis das gesamte GAL programmiert ist. Das Auslesen eines GALs geschieht ähnlich: Nach Anlegen der Adresse an RAG0-RAG5 werden die Bits der entsprechenden Adresse durch einen LOW-Impuls an /STR, in das interne Schieberegister geholt. Durch LOW-HIGH-Impulse an SCLK werden die einzelnen Bits aus dem Schieberegister zu SDOUT getaktet. Die Bit-Breite einer Adresse bestimmt die Anzahl der SCLK-Impulse, die nötig sind, um die Adresse vollständig zu programmieren bzw. auszulesen. Die interne Organisation der GALs (Adressen der Zeilen) sieht wie folgt aus: GAL16V8: Adresse Breite 0-31 Fuse-Matrix jeweils 64 Bit 32 Signatur 64 Bit 33-59 reservierter Bereich jeweils 64 Bit 60 Architektur-Kontroll-Wort ACW 82 Bit 61 Sicherheitszelle 62 reserviert 63 Bulk Erase GAL20V8: Adresse Breite 0-39 Fuse-Matrix jeweils 64 Bit 40 Signatur 64 Bit 41-59 reservierter Bereich jeweils 64 Bit 60 Architektur-Kontroll-Wort ACW 82 Bit 61 Sicherheitszelle 62 reserviert 63 Bulk Erase Das Architektur-Kontroll-Wort hat folgenden Aufbau (82 Bit breit): GAL16V8: Bits 0-31: 32 Bit Produkttermfreigabe 0-31 Bits 32-35: 4 Bit XOR(n) für OLMC-Pins 19-16 Bit 36: AC0-Bit Bits 37-44: 8 Bit AC1(n) für OLMC-Pins 19-12 Bit 45: SYN-Bit Bits 46-49: 4 Bit XOR(n) für OLMC-Pins 15-12 Bits 50-81: 32 Bit Produkttermfreigabe 32-63 GAL20V8: Bits 0-31: 32 Bit Produkttermfreigabe 0-31 Bits 32-35: 4 Bit XOR(n) für OLMC-Pins 22-19 Bit 36: AC0-Bit Bits 37-44: 8 Bit AC1(n) für OLMC-Pins 22-15 Bit 45: SYN-Bit Bits 46-49: 4 Bit XOR(n) für OLMC-Pins 18-15 Bits 50-81: 32 Bit Produkttermfreigabe 32-63 III.2 Schaltungsbeschreibung ---------------------------- Im folgenden Abschnitt werde ich auf die Funktionsweise meines GAL- Progammiergerätes eingehen. Dabei werde ich mich auf den Schaltplan beziehen. Sollten Sie diesen noch nicht besitzen, so können Sie diesen Abschnitt überspringen. Die Hardware wird am Parallelport des Amiga angeschlossen. Die verwendeten Datenleitungen sind dabei D0-D4 und die BUSY-Leitung. IC1, IC3, IC4 und IC5 sind achtstufige "seriell ein/parallel aus" Schiebe- register. Die Ausgänge der Schieberegister von IC3, IC4 und IC5 führen zu der Textool-Fassung für das GAL. Dadurch ist es möglich an jedem Pin (außer VCC und GND) des GALs, einen beliebigen Pegel (HIGH oder LOW) anzulegen. Die möglichen Ausgänge des GALs (Pin 14 bis 22) können über IC7 und IC6a ausgelesen werden. IC7 ist ein achtstufiges "parallel ein/seriell aus" Schieberegister. IC1 ist sozusagen die Schaltzentrale. Dieses IC steuert IC3, 4 und 5 (OE). Desweiteren werden über dieses IC die Spannungen für das GAL (VCC, Edit- Spannung) ein- bzw. ausgeschalten. Damit die ICs 1, 3, 4, 5, 7 individuell angesprochen werden können, ist für jedes dieser ICs eine eigene Takt-Leitung (Clk) vorhanden. Diese Clock- Leitungen werden über IC2, einen 1-aus-4-Decoder, aus den Datenleitungen D0 und D1 des Parallelports erzeugt. D3 bestimmt ob gelesen (low) oder ge- schrieben (high) werden soll. Dabei ist folgendes zu beachten: D3 darf nur dann low werden, wenn durch D0 und D1 das IC, das angesprochen werden soll, bereits selektiert ist. Ansonsten bekommt ein IC einen ungewollten Clock-Impuls und beim nächsten Strobe-Impuls (D2) liegen dann die falschen (um eins nach links geschobenen) Daten an den Ausgängen an. Der Strobe-Impuls für die Schieberegister wird aus D2 gewonnen. Wenn D2 auf high geht, werden die Daten in den Schieberegistern in die Ausgangs- register der ICs 1, 3, 4, 5 übernommen. Bei IC7 bewirkt ein D2 = high, daß die Daten an den Pins P1-P8 in das interne Schieberegister über- nommen werden und anschließend durch entsprechende Clock-Impulse über BUSY ausgelesen werden können. Über D4 gelangen die einzelnen Bits vom Amiga zum GAL-Brenner. Da an den Pins 2 und 4 der Textool-Fassung die Edit-Spannung von 16.5 Volt angelegt werden kann, muß IC4 durch die Dioden D2 und D3 vor Überspannung geschützt werden. Die Edit-Spannung wird von IC9, einem frequenzgesteuerten Sperrwandler, erzeugt. Die Spannung kann über den Spindeltrimmer R16 exakt eingestellt werden. Das Relais K1 legt die Versorgungsspannung des GALs auf Pin 24 des Textool- Sockels. Relais K2 legt entweder den Ausgang Q7 von IC3 oder +5V Ver- sorgungsspannung (je nach GALTyp) an Pin 22 des Textool-Sockels. Beide Relais werden über IC1 angesteuert. Die LED zeigt an, ob am Textool-Sockel eine Spannung anliegt oder nicht. Wenn die LED an ist, so darf weder ein GAL in die Fassung gesteckt, noch aus der Fassung heraus genommen werden. Zusammenfassung: Parallel-Port: D0-D1: Selektion der einzelnen ICs über Clk D2: Strobe-Impuls für IC 1, 3, 4, 5 D3: schreiben = low, lesen = high D4: Datenleitung für "Bits schreiben" BUSY: Datenleitung für "Bits lesen" IC1: Q1 16.5V aufbauen (noch nicht anlegen!) Q2 an Pin 2 Edit-Spannung für GAL20V8 anlegen Q3 an Pin 4 Eidt-Spannung für GAL16V8 anlegen Q5 Vcc anlegen Q6 OE für IC3, 4, 5 Q7 steuert LED an : high = on, low = off Q8 unbenützt IC3: Q1-Q8 Pin 16-23 des Textool-Sockels über R3-R8 IC4: Q1-Q8 Pin 1-8 des Textool-Sockels IC5: Q1-Q3 Pin 9-11 des Textool-Sockels Q4 Pin 13 des Textool-Sockels Q5-Q6 Pins 14, 15 des Textool-Sockels über R9, R10 IC6: a Pin 13 des Textool-Sockels lesen b IC7 auslesen IC7: P1-P8 Pin 14-21 des Textool-Sockels lesen III.3 Aufbau ------------ Im Anhang finden Sie die Stückliste. Die Kosten für die Bauteile (ohne Platine und Textool-Sockel) dürften um die 40 DM liegen. Wenn Sie sich den Textool-Sockel sparen wollen (ca. 20 DM), können Sie auch eine normale 24polige IC-Fassung verwenden. Da der Abstand der Pinreihen aber zu groß ist, müssen Sie die Querverbindungen zwischen den Pinreihen aufsägen, sauber abfeilen und anschließend die beiden Pinreihen im entsprechenden Abstand einlöten. Als IC-Fassungen sollten Sie nur Präzisions-Fassungen verwenden. Die 25polige Sub-D-Buchse (A1000) bzw. der Sub-D-Stecker (sonstige Amiga Modelle) wird wie folgt beschaltet: D0 = Pin 2 D1 = Pin 3 D2 = Pin 4 D3 = Pin 5 D4 = Pin 6 BUSY = Pin 11 Die Spannungsversorgung (+5V und Masse (GND)) müssen Sie sich entweder vom Expansion-Port des Amiga holen oder von einem externen Netzteil (das auf 5V stabilisiert ist!). Der GAL-Brenner hat eine maximale Stromaufnahme von ca. 220 mA. Wer seinen Amiga nicht gerade voll ausgebaut hat, der kann die +5V auch vom Parallel-Port holen. Allerdings - dieser ist beim A1000 für nur 100 mA ausgelegt (A500 noch weniger, A2000 und A3000 mehr). Dies hat aller- dings den Vorteil, daß keine zusätzlichen Kabel herum liegen. Ich habe mich für diese Variante entschlossen und bis jetzt hat sich mein A1000 nicht in Rauch aufgelöst. Aber Vorsicht, wie schon gesagt, beim A500 oder einem voll ausgabauten A2000, A3000... kann das schon wieder ganz anders aussehen. Also für mutige: VCC (+5V) = A1000 : Pin 23 A500, A2000, A3000 usw. : Pin 14 GND = A1000 : Pin 14 A500, A2000, A3000 usw. : Pin 17 Das Hauptproblem beim Aufbau des GAL-Brenners ist wahrscheinlich die Platine. Da die wenigsten in der Lage seine dürften eine doppelseitige, durch- kontaktierte Platine herzustellen, ist die beste Lösung die, daß man die Schaltung mit Hilfe der Fädeltechnik auf eine einseitige Euro-Loch- rasterplatine aufbaut. Dazu werden die Bauteile einfach auf die Platine gelötet und anschließend durch dünne Drähte miteinander verbunden. Wenn das Ganze auch einen einigermaßen sauberen Eindruck machen soll, kann man auch Fädelleisten (Verdrahtungskämme) verwenden. Entlang dieser Leisten können die Drähte dann geführt werden, so daß nicht alles drunter und drüber geht. Wer die Fädeltechnik noch nicht kennt, der kann sie sich ja einmal im Fachgeschäft erklären lassen. Mit dieser Technik hab' ich meinen GAL-Brenner und etliche andere Projekte aufgebaut (unter anderem einen Einplatinen-Computer auf 68000er-Basis). Einen Vorschlag zur Anordnung der Bauteile auf der Platine, schicke ich mit dem Schaltplan mit. Wenn Sie die Schaltung aufgebaut und an den Amiga angeschlossen haben und dieser NICHT explodiert ist, können Sie das Testprogramm "GALerTest" starten. Das Programm legt verschiedene Pegel an die Pins der Textool-Fassung, die Sie mit einem Meßgerät überprüfen können. Die Programmierspannung von +16.5 V kann mit dem Spindeltrimmer R16 eingestellt werden. NICHT VERGESSEN: Programmierspannung von +16.5 V einstellen (mit Spindel- trimmer R16), sonst funktioniert der GAL-Brenner NICHT!!!! ("GALerTest" starten und bis zum entsprechenden Testpunkt durchklicken) Falls sich Ihr GAL-Brenner genau so verhält wie es das Testprogramm ver- langt, können Sie probeweise ein GAL brennen und mit dem GAL-Prüfer über- prüfen. Wenn es funktioniert, dann dürfte in der Hardware kein Fehler sein. GALs vom Typ GAL16V8 müssen so in die Textool-Fassung gesteckt werden, daß Pin 1 des GALs mit Pin 3 der Fassung übereinstimmt. Bei GALs vom Typ GAL20V8 muß Pin 1 des GALs mit Pin 1 der Fassung übereinstimmen. Noch eine Anregung: Die Hardware des GAL-Brenners ist so ausgelegt, daß sie auf allen Computern mit Centronics-Port läuft. Es muß sich nur noch jemand finden lassen, der die Software auf den entsprechenden Computer (MS-Dosen, Atari ST, Mac, Archimedes, NeXT, Sun, Cray, Suprenum, ...) (größenwahnsinnig werd) umschreibt. Voraussetzung ist allerdings, daß die umgeschriebene Software Shareware (Gebühr max. 30 DM) oder PD ist und daß auf mein Copyright auf die Hardware und Amiga-GALer-Software hingewiesen wird. Übrigens, wenn jemand Lust hat das ganze Gesülze ins Englische zu über- sezten, so kann er das gerne tun und mir zukommen lassen. Dann haben auch die außerhalb von "Good Old Germany" etwas von dem Projekt. Tja, das war's dann wohl. Tschau und viel Spaß mit den putzigen GALs. P.S.: hat mein Auto 60 - Falls sich zeigt, daß dieser GAL-Brenner einigermaßen angekommen ist (und sich die Klagen über zerfetzte Amigas in Grenzen halten), werde ich mich aufraffen und auch einige meiner anderen Projekte als Public-Domain oder Shareware 'rausgeben. ************************************************************************** Anhang ====== Schlüsselwörter der Eingabe-Datei: ---------------------------------- GAL16V8, GAL20V8 bestimmt den GAL-Typ NC nichtverwendeter Pin GND Masse (=LOW) VCC +5V (=HIGH) .T Ausgangspin ist Tristate-Ausgang .E Tristate-Freigabe durch Produktterm .R Ausgangspin ist Register-Ausgang = Ausgangspin wird eine Gleichung zugewiesen + ODER - Verknüpfung * UND - Verknüpfung / NICHT DESCRIPTION kennzeichnet das Ende der Boole'schen Gleichungen Stückliste: ----------- ICs: ---- IC1, IC3, IC4, IC5 : 4 x 4094 IC2 : 1 x 4555 IC6 : 1 x 4503 IC7 : 1 x 4021 IC8 : 1 x 74LS06 IC9 : 1 x TL 497 Dioden: ------- D1-D4 : 4 x 1N4148 LED : 1 x rot, 3 mm Transistoren: ------------- T2, T4, T5 : 3 x BC237B T1, T3 : 2 x BC307B Widerstände (1/4 Watt): ----------------------- R1, R2, R17 : 3 x 1 KOhm R3-13, R19-26 : 19 x 10 KOhm R28-32 : 5 x 1,8 KOhm R14 : 1 x 1 Ohm R15 : 1 x 33 KOhm R16 : 1 x 10 KOhm Spindeltrimmer R18 : 1 x 4,7 Ohm R27 : 1 x 47 Ohm R33 : 1 x 22 KOhm R34 : 1 x 220 Ohm Relais: ------- K1, K2 : 2 x Siemens V23101A3A101 o.ä. (5V, 1 x Wechselkontakt) Spule: ------ L1 : 1 x 150 uH, Miniatur-Festinduktivität Kondensatoren: -------------- C1 : 1 x 100 pF C2 : 1 x 4,7 uF, Tantal C3 : 1 x 100 nF C4 : 1 x 220 uF, 25V C5, C6 : 2 x 120 nF Sonstiges: ---------- IC-Fassungen 7 x 16polig 2 x 14polig 1 x Textool-Fassung 24polig, schmal! 25polige Sub-D-Buchse (für Amiga 1000) bzw. 25poligen Sub-D-Stecker (für alle anderen Amiga-Typen) Legende: u = mikro Literaturhinweise: ------------------ 1) GALs - Programmierbare Logikbausteine in Theorie und Praxis Bitterle Franzis-Verlag Dieses Buch ist vorallem für Anfänger gut geeignet. 2) Programmable Logic Manual - GAL Products SGS-Thomson Dieses Buch (englisch) ist eher für den Profi geeignet.